{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = np.sin(x_mesh+y_mesh*5)+np.exp(-x_mesh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.contour.QuadContourSet at 0x21a7f12d610>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.contourf(x_domain, y_domain, truth_smooth,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = truth_smooth + np.random.normal(loc=0.0, scale=0.1, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:    6.65748 | domain_loss:  558.45874 | bdc_loss:    1.08373\n",
      "epoch:  200.00000 | total_loss:    2.26832 | domain_loss:  123.40150 | bdc_loss:    1.04475\n",
      "epoch:  400.00000 | total_loss:    1.40802 | domain_loss:   40.80730 | bdc_loss:    1.01004\n",
      "epoch:  600.00000 | total_loss:    1.14438 | domain_loss:   17.63321 | bdc_loss:    0.97782\n",
      "epoch:  800.00000 | total_loss:    1.03004 | domain_loss:    9.25673 | bdc_loss:    0.94694\n",
      "epoch: 1000.00000 | total_loss:    0.96399 | domain_loss:    5.66432 | bdc_loss:    0.91651\n",
      "epoch: 1200.00000 | total_loss:    0.91602 | domain_loss:    3.89692 | bdc_loss:    0.88591\n",
      "epoch: 1400.00000 | total_loss:    0.87544 | domain_loss:    2.92256 | bdc_loss:    0.85476\n",
      "epoch: 1600.00000 | total_loss:    0.83803 | domain_loss:    2.32312 | bdc_loss:    0.82303\n",
      "epoch: 1800.00000 | total_loss:    0.80227 | domain_loss:    1.91283 | bdc_loss:    0.79105\n",
      "epoch: 2000.00000 | total_loss:    0.76806 | domain_loss:    1.60720 | bdc_loss:    0.75958\n",
      "epoch: 2200.00000 | total_loss:    0.73612 | domain_loss:    1.36836 | bdc_loss:    0.72974\n",
      "epoch: 2400.00000 | total_loss:    0.70750 | domain_loss:    1.17900 | bdc_loss:    0.70273\n",
      "epoch: 2600.00000 | total_loss:    0.68311 | domain_loss:    1.02912 | bdc_loss:    0.67962\n",
      "epoch: 2800.00000 | total_loss:    0.66343 | domain_loss:    0.91006 | bdc_loss:    0.66094\n",
      "epoch: 3000.00000 | total_loss:    0.64827 | domain_loss:    0.81391 | bdc_loss:    0.64660\n",
      "epoch: 3200.00000 | total_loss:    0.63690 | domain_loss:    0.73491 | bdc_loss:    0.63591\n",
      "epoch: 3400.00000 | total_loss:    0.62822 | domain_loss:    0.66997 | bdc_loss:    0.62780\n",
      "epoch: 3600.00000 | total_loss:    0.62110 | domain_loss:    0.61759 | bdc_loss:    0.62114\n",
      "epoch: 3800.00000 | total_loss:    0.61460 | domain_loss:    0.57655 | bdc_loss:    0.61498\n",
      "epoch: 4000.00000 | total_loss:    0.60801 | domain_loss:    0.54541 | bdc_loss:    0.60865\n",
      "epoch: 4200.00000 | total_loss:    0.60088 | domain_loss:    0.52254 | bdc_loss:    0.60167\n",
      "epoch: 4400.00000 | total_loss:    0.59285 | domain_loss:    0.50639 | bdc_loss:    0.59372\n",
      "epoch: 4600.00000 | total_loss:    0.58359 | domain_loss:    0.49565 | bdc_loss:    0.58448\n",
      "epoch: 4800.00000 | total_loss:    0.57273 | domain_loss:    0.48923 | bdc_loss:    0.57357\n",
      "epoch: 5000.00000 | total_loss:    0.55980 | domain_loss:    0.48621 | bdc_loss:    0.56054\n",
      "epoch: 5200.00000 | total_loss:    0.54423 | domain_loss:    0.48569 | bdc_loss:    0.54482\n",
      "epoch: 5400.00000 | total_loss:    0.52534 | domain_loss:    0.48669 | bdc_loss:    0.52573\n",
      "epoch: 5600.00000 | total_loss:    0.50240 | domain_loss:    0.48809 | bdc_loss:    0.50255\n",
      "epoch: 5800.00000 | total_loss:    0.47481 | domain_loss:    0.48890 | bdc_loss:    0.47466\n",
      "epoch: 6000.00000 | total_loss:    0.44227 | domain_loss:    0.48886 | bdc_loss:    0.44180\n",
      "epoch: 6200.00000 | total_loss:    0.40508 | domain_loss:    0.48891 | bdc_loss:    0.40423\n",
      "epoch: 6400.00000 | total_loss:    0.36421 | domain_loss:    0.49101 | bdc_loss:    0.36293\n",
      "epoch: 6600.00000 | total_loss:    0.32127 | domain_loss:    0.49687 | bdc_loss:    0.31949\n",
      "epoch: 6800.00000 | total_loss:    0.27825 | domain_loss:    0.50652 | bdc_loss:    0.27595\n",
      "epoch: 7000.00000 | total_loss:    0.23719 | domain_loss:    0.51896 | bdc_loss:    0.23434\n",
      "epoch: 7200.00000 | total_loss:    0.19982 | domain_loss:    0.53415 | bdc_loss:    0.19644\n",
      "epoch: 7400.00000 | total_loss:    0.16745 | domain_loss:    0.55307 | bdc_loss:    0.16356\n",
      "epoch: 7600.00000 | total_loss:    0.14085 | domain_loss:    0.57621 | bdc_loss:    0.13645\n",
      "epoch: 7800.00000 | total_loss:    0.12013 | domain_loss:    0.60318 | bdc_loss:    0.11525\n",
      "epoch: 8000.00000 | total_loss:    0.10483 | domain_loss:    0.63348 | bdc_loss:    0.09949\n",
      "epoch: 8200.00000 | total_loss:    0.09405 | domain_loss:    0.66654 | bdc_loss:    0.08827\n",
      "epoch: 8400.00000 | total_loss:    0.08666 | domain_loss:    0.70145 | bdc_loss:    0.08045\n",
      "epoch: 8600.00000 | total_loss:    0.08152 | domain_loss:    0.73704 | bdc_loss:    0.07490\n",
      "epoch: 8800.00000 | total_loss:    0.07755 | domain_loss:    0.77205 | bdc_loss:    0.07054\n",
      "epoch: 9000.00000 | total_loss:    0.07384 | domain_loss:    0.80401 | bdc_loss:    0.06646\n",
      "epoch: 9200.00000 | total_loss:    0.06952 | domain_loss:    0.82228 | bdc_loss:    0.06192\n",
      "epoch: 9400.00000 | total_loss:    0.06413 | domain_loss:    0.82569 | bdc_loss:    0.05644\n",
      "epoch: 9600.00000 | total_loss:    0.05796 | domain_loss:    0.80927 | bdc_loss:    0.05037\n",
      "epoch: 9800.00000 | total_loss:    0.05121 | domain_loss:    0.75243 | bdc_loss:    0.04413\n",
      "epoch: 10000.00000 | total_loss:    0.04414 | domain_loss:    0.66098 | bdc_loss:    0.03791\n",
      "epoch: 10200.00000 | total_loss:    0.03714 | domain_loss:    0.54941 | bdc_loss:    0.03196\n",
      "epoch: 10400.00000 | total_loss:    0.03078 | domain_loss:    0.43815 | bdc_loss:    0.02666\n",
      "epoch: 10600.00000 | total_loss:    0.02546 | domain_loss:    0.34088 | bdc_loss:    0.02227\n",
      "epoch: 10800.00000 | total_loss:    0.02130 | domain_loss:    0.26321 | bdc_loss:    0.01886\n",
      "epoch: 11000.00000 | total_loss:    0.01821 | domain_loss:    0.20423 | bdc_loss:    0.01633\n",
      "epoch: 11200.00000 | total_loss:    0.01597 | domain_loss:    0.16067 | bdc_loss:    0.01451\n",
      "epoch: 11400.00000 | total_loss:    0.01436 | domain_loss:    0.12986 | bdc_loss:    0.01319\n",
      "epoch: 11600.00000 | total_loss:    0.01320 | domain_loss:    0.10844 | bdc_loss:    0.01224\n",
      "epoch: 11800.00000 | total_loss:    0.01238 | domain_loss:    0.09397 | bdc_loss:    0.01156\n",
      "epoch: 12000.00000 | total_loss:    0.01182 | domain_loss:    0.08413 | bdc_loss:    0.01109\n",
      "epoch: 12200.00000 | total_loss:    0.01144 | domain_loss:    0.07755 | bdc_loss:    0.01077\n",
      "epoch: 12400.00000 | total_loss:    0.01119 | domain_loss:    0.07314 | bdc_loss:    0.01056\n",
      "epoch: 12600.00000 | total_loss:    0.01103 | domain_loss:    0.07013 | bdc_loss:    0.01043\n",
      "epoch: 12800.00000 | total_loss:    0.01093 | domain_loss:    0.06805 | bdc_loss:    0.01035\n",
      "epoch: 13000.00000 | total_loss:    0.01086 | domain_loss:    0.06653 | bdc_loss:    0.01029\n",
      "epoch: 13200.00000 | total_loss:    0.01081 | domain_loss:    0.06527 | bdc_loss:    0.01026\n",
      "epoch: 13400.00000 | total_loss:    0.01077 | domain_loss:    0.06418 | bdc_loss:    0.01023\n",
      "epoch: 13600.00000 | total_loss:    0.01073 | domain_loss:    0.06314 | bdc_loss:    0.01020\n",
      "epoch: 13800.00000 | total_loss:    0.01070 | domain_loss:    0.06212 | bdc_loss:    0.01018\n",
      "epoch: 14000.00000 | total_loss:    0.01067 | domain_loss:    0.06108 | bdc_loss:    0.01017\n",
      "epoch: 14200.00000 | total_loss:    0.01065 | domain_loss:    0.06000 | bdc_loss:    0.01015\n",
      "epoch: 14400.00000 | total_loss:    0.01062 | domain_loss:    0.05927 | bdc_loss:    0.01013\n",
      "epoch: 14600.00000 | total_loss:    0.01059 | domain_loss:    0.05775 | bdc_loss:    0.01012\n",
      "epoch: 14800.00000 | total_loss:    0.01056 | domain_loss:    0.05659 | bdc_loss:    0.01010\n",
      "epoch: 15000.00000 | total_loss:    0.01054 | domain_loss:    0.05544 | bdc_loss:    0.01008\n",
      "epoch: 15200.00000 | total_loss:    0.01051 | domain_loss:    0.05417 | bdc_loss:    0.01007\n",
      "epoch: 15400.00000 | total_loss:    0.01048 | domain_loss:    0.05280 | bdc_loss:    0.01005\n",
      "epoch: 15600.00000 | total_loss:    0.01045 | domain_loss:    0.05147 | bdc_loss:    0.01004\n",
      "epoch: 15800.00000 | total_loss:    0.01042 | domain_loss:    0.05042 | bdc_loss:    0.01002\n",
      "epoch: 16000.00000 | total_loss:    0.01039 | domain_loss:    0.04883 | bdc_loss:    0.01000\n",
      "epoch: 16200.00000 | total_loss:    0.01036 | domain_loss:    0.04745 | bdc_loss:    0.00999\n",
      "epoch: 16400.00000 | total_loss:    0.01033 | domain_loss:    0.04625 | bdc_loss:    0.00997\n",
      "epoch: 16600.00000 | total_loss:    0.01030 | domain_loss:    0.04481 | bdc_loss:    0.00995\n",
      "epoch: 16800.00000 | total_loss:    0.01027 | domain_loss:    0.04349 | bdc_loss:    0.00994\n",
      "epoch: 17000.00000 | total_loss:    0.01024 | domain_loss:    0.04220 | bdc_loss:    0.00992\n",
      "epoch: 17200.00000 | total_loss:    0.01021 | domain_loss:    0.04093 | bdc_loss:    0.00990\n",
      "epoch: 17400.00000 | total_loss:    0.01019 | domain_loss:    0.03970 | bdc_loss:    0.00989\n",
      "epoch: 17600.00000 | total_loss:    0.01016 | domain_loss:    0.03852 | bdc_loss:    0.00987\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.01013 | domain_loss:    0.03741 | bdc_loss:    0.00985\n",
      "epoch: 18000.00000 | total_loss:    0.01011 | domain_loss:    0.03669 | bdc_loss:    0.00984\n",
      "epoch: 18200.00000 | total_loss:    0.01007 | domain_loss:    0.03517 | bdc_loss:    0.00982\n",
      "epoch: 18400.00000 | total_loss:    0.01005 | domain_loss:    0.03408 | bdc_loss:    0.00981\n",
      "epoch: 18600.00000 | total_loss:    0.01002 | domain_loss:    0.03319 | bdc_loss:    0.00979\n",
      "epoch: 18800.00000 | total_loss:    0.01000 | domain_loss:    0.03212 | bdc_loss:    0.00977\n",
      "epoch: 19000.00000 | total_loss:    0.00997 | domain_loss:    0.03099 | bdc_loss:    0.00976\n",
      "epoch: 19200.00000 | total_loss:    0.00995 | domain_loss:    0.03072 | bdc_loss:    0.00974\n",
      "epoch: 19400.00000 | total_loss:    0.00992 | domain_loss:    0.02956 | bdc_loss:    0.00973\n",
      "epoch: 19600.00000 | total_loss:    0.00990 | domain_loss:    0.02854 | bdc_loss:    0.00971\n",
      "epoch: 19800.00000 | total_loss:    0.00989 | domain_loss:    0.02922 | bdc_loss:    0.00970\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0001), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.009696575014951865"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean((uxy[0,:,:,0]-truth_data)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth':np.asarray(truth_smooth),\n",
    "                     'samples':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0)}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
